home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 October: Mac OS SDK / Dev.CD Oct 96 SDK / Dev.CD Oct 96 SDK1.toast / Development Kits (Disc 1) / AppleScript / Development Tools / Sample Code / Sample OSA Component / In MW C with Tester / MyOSAComponentRoutines.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-08  |  19.0 KB  |  715 lines  |  [TEXT/MMCC]
  1. /*
  2.  File MyOSAComponentRoutines.c
  3.  
  4.  
  5.  
  6.  Copyright © 1992-1993 Apple Computer, Inc. All rights reserved.}
  7.  
  8.  This is a sample program to implement the OSA interface. 
  9.  In this sample program, the source is the same as the internal compiled form. 
  10.  So compile and decompile just consists of copying and rename, and this is very 
  11.  unlike other OSA implementation. However, there is a lot of scripting language 
  12.  which just interprets the source and this sample program can be useful.
  13.  
  14.  Ported over to C 9/20/95
  15.  R.Silva
  16.  
  17.  
  18.  
  19. */
  20.  
  21. #ifdef THINK_C
  22. #define        applec
  23. #endif
  24.  
  25. //#include     "myHeaders.h"
  26.  
  27. #include    <Errors.h>
  28. #include    <TextEdit.h>
  29. #include    <Components.h>
  30. #include    <OSAComp.h>
  31.  
  32. #include    "MyOSAComponent.h"
  33. #include    "MyOSAComponentRoutines.h"
  34.  
  35.  
  36. //prototyping
  37. ComponentResult FindSlotAndPutIt(GlobalsHandle globals, AEDesc theDesc,long *slotID);                              
  38. long     FindScriptIDSlot(GlobalsHandle globals);
  39. void      NukeIt(AEDesc *theDesc);
  40. void     ClearErrorDesc(GlobalsHandle globals);
  41. OSErr     TextToStxt(AEDesc textDesc, AEDesc *result);
  42. ComponentResult TryDoScript(GlobalsHandle globals, AEDesc *scriptData, int  *num);
  43. ComponentResult ActualDoScript(GlobalsHandle globals, AEDesc *scriptData, AEDesc *result);
  44. int        myStrcmp( char * firstString, char * secString);
  45. OSErr     myStrcat( char * firstString, char * secString);
  46. int     myStrlen( char * theString); 
  47.                          
  48. /* ------------------------------------------------------------------------- */
  49. //  put a desc into a slot, if slotID starts as 0 find a new slot, 
  50. //  otherwise reuse the slot ID 
  51. //
  52. ComponentResult FindSlotAndPutIt(GlobalsHandle globals, AEDesc theDesc, long *slotID)
  53. {
  54.     OSErr err = noErr;
  55.     AEDesc  *oldDesc;
  56.     long    mySlot;
  57.          
  58.     mySlot = *slotID;
  59.     HLock((Handle)globals);
  60.     if( theDesc.dataHandle == nil){ 
  61.         mySlot = 0;
  62.         err = memFullErr;
  63.     }
  64.     else{
  65.         if( mySlot == 0 ){ 
  66.             mySlot = FindScriptIDSlot(globals); //find an empty slot
  67.         }
  68.         else{
  69.             //reuse an existing slot, we first dispose the old content
  70.             oldDesc =  &((*globals)->scriptIDSlot[mySlot]);
  71.             AEDisposeDesc(oldDesc);
  72.         }
  73.         if( slotID != 0 ) {
  74.             //keep the same handle
  75.             ((*globals)->scriptIDSlot[mySlot] ).dataHandle = theDesc.dataHandle;
  76.             ((*globals)->scriptIDSlot[mySlot] ).descriptorType = theDesc.descriptorType;
  77.         }
  78.         else{
  79.             err = memFullErr; //no slot available, treat it as memory error because
  80.                               //in a more realistic program we would expand the slots 
  81.             mySlot = 0;
  82.             //get rid of it since it wasnt used
  83.             AEDisposeDesc(&theDesc);
  84.         }
  85.     }
  86.     HUnlock((Handle)globals);
  87.     *slotID = mySlot;
  88.          
  89.     return err;
  90. }
  91. //search for a empty slot and return the slot ID, return 0 if none is available
  92. //start at the number 1 slot,  zero means  "get a new slot"
  93. //
  94. long FindScriptIDSlot(GlobalsHandle globals)
  95. {
  96.     int  i;
  97.  
  98.     for( i = 1; i<  MaxIDSlot ; i++) { 
  99.         if( ((*globals)->scriptIDSlot)[i].dataHandle == nil ) {
  100.         break;
  101.         }
  102.     }
  103.     if(i == MaxIDSlot) i = 0;
  104.     return i;
  105. }
  106. //
  107. //make a copy, strip the trailer and put it into a slot
  108. //
  109. pascal ComponentResult DoOSALoad(Handle myGlobals, AEDesc *scriptData,
  110.                        long  modeFlags, OSAID *resultingScriptID)
  111. {
  112.     ComponentResult err;
  113.     AEDesc  descCopy;
  114.     DescType  itsType;
  115.     GlobalsHandle globals; 
  116.  
  117.  
  118.     globals = (GlobalsHandle) myGlobals;
  119.         
  120.     err = errOSABadStorageType;
  121.     if ((*scriptData).descriptorType == kOSAGenericScriptingComponentSubtype) {  
  122.         if( OSAGetStorageType((*scriptData).dataHandle, &itsType) == noErr ) {  
  123.             if(  itsType == MySignature ) {  
  124.                 err = AEDuplicateDesc(scriptData, &descCopy);
  125.                 if( err == noErr) { err = OSARemoveStorageType(descCopy.dataHandle); }
  126.                 //internally we store as type 'SMPL'
  127.                 descCopy.descriptorType = MySignature;
  128.                 //we want a new OSAID 
  129.                 resultingScriptID = 0;  
  130.                 err = FindSlotAndPutIt(globals, descCopy, (long *) resultingScriptID);
  131.             }
  132.         }
  133.     }
  134.     return err;
  135. }
  136. //make a null descriptor
  137. void  NukeIt(AEDesc *theDesc)
  138. { 
  139.     theDesc->descriptorType = typeNull;
  140.     theDesc->dataHandle = nil;
  141. }
  142.  
  143. //make a copy of content in the slot and add trailer
  144. //
  145. pascal ComponentResult DoOSAStore(GlobalsHandle globals, OSAID scriptID,
  146.                         DescType desiredType,long  modeFlags,
  147.                         AEDesc  *resultingScriptData)
  148. {    
  149.     ComponentResult err;
  150.     
  151.     NukeIt(resultingScriptData);
  152.     if( (scriptID <= 0) || (scriptID > MaxIDSlot - 1) ) {
  153.         err = errOSAInvalidID;
  154.     }
  155.     else{
  156.         HLock((Handle)globals);
  157.         err = AEDuplicateDesc( &((*globals)->scriptIDSlot[scriptID]),resultingScriptData) ;
  158.         HUnlock((Handle)globals);
  159.         if( err != noErr ) { 
  160.             NukeIt(resultingScriptData); 
  161.         }
  162.         if( (*resultingScriptData).dataHandle == nil){
  163.             err = errOSAInvalidID;
  164.         }
  165.         else{ 
  166.             err = OSAAddStorageType( (*resultingScriptData).dataHandle, (*resultingScriptData).descriptorType);
  167.             if( err == noErr) { 
  168.                 (*resultingScriptData).descriptorType = kOSAGenericScriptingComponentSubtype;
  169.             }
  170.             else {
  171.                 AEDisposeDesc(resultingScriptData);
  172.                 NukeIt(resultingScriptData);
  173.             }
  174.         }
  175.     }
  176.     return err;
  177. }
  178. //fetch the content of the error descriptor
  179. //
  180. pascal ComponentResult DoOSAScriptError(GlobalsHandle globals, OSType selector,
  181.                               DescType desiredType, AEDesc *resultingErrorDescription)
  182. {
  183.     ComponentResult err;
  184.     long i;
  185.     AERecord aRec ;
  186.     AEDesc *myErrorDesc ;
  187.     int errNum;
  188.     
  189.     NukeIt(resultingErrorDescription);
  190.     if( selector == kOSAErrorNumber ) { 
  191.         HLock((Handle)globals);
  192.         errNum = (*globals)->errorNumber;
  193.         HUnlock((Handle)globals);
  194.         err = AECoercePtr(typeShortInteger, &errNum, sizeof(int), desiredType, resultingErrorDescription);
  195.     }
  196.     else if ( selector == kOSAErrorMessage) {
  197.         HLock((Handle)globals);
  198.         myErrorDesc = &((*globals)->errorDesc);
  199.         if( (desiredType == typeChar) || (desiredType == typeWildCard) ){ 
  200.             err = AEDuplicateDesc(myErrorDesc, resultingErrorDescription);
  201.         }
  202.         else if ( desiredType == 'STXT') { 
  203.             err = TextToStxt(*myErrorDesc, resultingErrorDescription);
  204.         }
  205.         else {
  206.             err = AECoerceDesc(myErrorDesc, desiredType, resultingErrorDescription);
  207.         }
  208.         HUnlock((Handle)globals);
  209.     }
  210.     else if( selector == kOSAErrorRange) {
  211.         //in this simple example, we make the error range to include everything
  212.         err = AECreateList(nil, 0, true, &aRec);
  213.         if( err == noErr) {
  214.             i = 0;
  215.             AEPutKeyPtr(&aRec, keyOSASourceStart, typeLongInteger, &i, sizeof(i));
  216.             i = 30000;
  217.             AEPutKeyPtr(&aRec, keyOSASourceEnd, typeLongInteger, &i, sizeof(i) );
  218.             if( desiredType == typeAERecord ) {
  219.                 err = AEDuplicateDesc(&aRec, resultingErrorDescription);
  220.             }
  221.             else {
  222.                 if( desiredType == typeWildCard ){  
  223.                     desiredType = typeOSAErrorRange; 
  224.                     err = AECoerceDesc(&aRec, desiredType, resultingErrorDescription);
  225.                 }
  226.             }
  227.             AEDisposeDesc(&aRec);
  228.         }
  229.     }
  230.     else{
  231.         err = errOSABadSelector;
  232.     }
  233.     return err;
  234. }
  235. //
  236. //dispose the descriptor in the slot I check whether the dataHandle is nil first  
  237. //
  238. pascal ComponentResult DoOSADispose(GlobalsHandle  globals,
  239.                           OSAID scriptID)
  240. {    
  241.     if( (scriptID > 0) && (scriptID < MaxIDSlot) ) { 
  242.         HLock((Handle)globals);
  243.         if(((*globals)->scriptIDSlot[scriptID]).dataHandle != nil ){
  244.             AEDisposeDesc(&((*globals)->scriptIDSlot[scriptID]));
  245.             ((*globals)->scriptIDSlot[scriptID]).dataHandle = nil;
  246.         }
  247.         HUnlock((Handle)globals);
  248.     }
  249.     return noErr;
  250. }
  251. //
  252. //since in this sample program, internal form is the same as source form
  253. //except for the descriptor type, we can just call CompileExecute 
  254. pascal ComponentResult DoOSAExecute(GlobalsHandle globals,  OSAID compiledScriptID,
  255.                           OSAID contextID, long  modeFlags, OSAID *resultingScriptValueID)
  256. {
  257.     AEDesc myDesc;
  258.     ComponentResult  err;
  259.  
  260.     *resultingScriptValueID = 0;
  261.     if( (compiledScriptID <= 0) || (compiledScriptID > MaxIDSlot - 1) )   
  262.         return errOSAInvalidID;
  263.     else{
  264.         HLock((Handle)globals);
  265.         err = AEDuplicateDesc(&((*globals)->scriptIDSlot[compiledScriptID]), &myDesc);
  266.         HUnlock((Handle)globals);
  267.         if(err == noErr){
  268.             err = DoOSACompileExecute(globals, &myDesc, 
  269.                               contextID, modeFlags, resultingScriptValueID);
  270.               AEDisposeDesc(&myDesc);
  271.         }
  272.     }
  273.     return err;
  274. }
  275. //
  276. //in this program, we have no special form for display so just coerce it
  277. //
  278. pascal ComponentResult DoOSADisplay(GlobalsHandle globals, OSAID  scriptValueID,
  279.                           DescType  desiredType, long modeFlags,
  280.                           AEDesc *resultingText)
  281. {
  282.     
  283.     return DoOSACoerceToDesc(globals, scriptValueID, desiredType, modeFlags, resultingText);
  284. }
  285. //
  286. //since internal form is same as source, just change the dataType and call TryDoScript, 
  287. //if it compiles then just store it
  288. pascal ComponentResult DoOSACompile(GlobalsHandle  globals, AEDesc  *sourceData,
  289.                           long modeFlags, OSAID *resultingCompiledScriptID)
  290. {
  291.     ComponentResult err;
  292.     AEDesc descCopy;
  293.     int  num;
  294.         
  295.     if( (*sourceData).descriptorType == typeChar) { 
  296.         (*sourceData).descriptorType = MySignature;
  297.         err = TryDoScript(globals, sourceData, &num);
  298.         if( err == noErr ) { 
  299.             err = AEDuplicateDesc(sourceData, &descCopy);
  300.             if(err == noErr){    
  301.                 err = FindSlotAndPutIt(globals, descCopy, (long *) resultingCompiledScriptID);
  302.             }
  303.         }  
  304.     }
  305.     else{
  306.         err = errOSABadStorageType;
  307.     }    
  308.     return err;
  309. }
  310. //in this sample program, source is same as internal form and  
  311. //there is no special formatting, so just call coerce 
  312. //
  313. pascal ComponentResult DoOSAGetSource(GlobalsHandle globals, OSAID  scriptID,
  314.                             DescType desiredType, AEDesc *resultingSourceData)
  315. {
  316.     return DoOSACoerceToDesc(globals, scriptID, desiredType, 0, resultingSourceData);
  317. }
  318. //
  319. //just store a copy into the slot
  320. //
  321. pascal  ComponentResult DoOSACoerceFromDesc(GlobalsHandle globals, AEDesc *scriptData,
  322.                                  long modeFlags, OSAID *resultingScriptValueID)
  323. {
  324.     
  325.     ComponentResult err;
  326.     AEDesc  descCopy;
  327.  
  328.     err = AEDuplicateDesc(scriptData, &descCopy);
  329.     if( err == noErr ) { 
  330.         *resultingScriptValueID = 0; //put it in a new slot
  331.         err = FindSlotAndPutIt(globals, descCopy, (long *) resultingScriptValueID);
  332.     }
  333.     return err;
  334. }
  335.  
  336. //fetch from the slot and coerce it, if it is source we rename the 
  337. //type because internal form is same as the source text
  338. //
  339. pascal ComponentResult DoOSACoerceToDesc(GlobalsHandle globals, OSAID scriptValueID,
  340.                                DescType  desiredType, long modeFlags, AEDesc *result)
  341. {
  342.     ComponentResult err;
  343.     AEDesc myScriptValue;
  344.  
  345.     if( (scriptValueID <= 0) || (scriptValueID > MaxIDSlot - 1)) { 
  346.         err = errOSAInvalidID;
  347.     }
  348.     else {
  349.         HLock((Handle)globals);
  350.         err = AEDuplicateDesc( &((*globals)->scriptIDSlot[scriptValueID]),&myScriptValue );
  351.         HUnlock((Handle)globals);
  352.         if( err == noErr ){
  353.             if( myScriptValue.descriptorType == MySignature ){  
  354.                 myScriptValue.descriptorType = typeChar; 
  355.             }
  356.             if( myScriptValue.descriptorType == desiredType ) {
  357.                 err = AEDuplicateDesc(&myScriptValue, result);
  358.             }
  359.             else if( desiredType == 'STXT') { 
  360.                 err = TextToStxt(myScriptValue, result);
  361.             }
  362.             else {
  363.                 err = AECoerceDesc(&myScriptValue, desiredType, result);
  364.             }
  365.             AEDisposeDesc(&myScriptValue);
  366.         }
  367.     }
  368.     return err;
  369. }
  370.  
  371. //strip the trailer, execute it and put back the trailer
  372. //there is chance we cannot restore the original form although we are try our best 
  373. //this really calls for a GetScriptDataSize call in OSAComp 
  374. pascal ComponentResult DoOSALoadExecute(GlobalsHandle globals, AEDesc *scriptData,
  375.                               OSAID contextID,  long modeFlags,
  376.                               OSAID *resultingScriptValueID )
  377. {
  378.     ComponentResult  err;
  379.     DescType itsType;
  380.  
  381.     err = errOSABadStorageType;
  382.     if( (*scriptData).descriptorType == kOSAGenericScriptingComponentSubtype ) {
  383.         if( OSAGetStorageType((*scriptData).dataHandle, &itsType) == noErr ) {  
  384.             if( itsType == MySignature ) { 
  385.                 err = OSARemoveStorageType((*scriptData).dataHandle);
  386.                 if( err == noErr ) { 
  387.                     err = DoOSACompileExecute(globals, scriptData, 0, 0, resultingScriptValueID);
  388.                     if( OSAAddStorageType((*scriptData).dataHandle, MySignature) != noErr ) {
  389.                         //we are in deep trouble, we changed scriptData and cannot put it back
  390.                         //dispose result to get back the memory
  391.                         DoOSADispose(globals, *resultingScriptValueID);
  392.                         resultingScriptValueID = 0;
  393.                         //now try again
  394.                         OSAAddStorageType((*scriptData).dataHandle, MySignature);
  395.                         err = memFullErr;  //fail because we don't have enough memory
  396.                     }
  397.                 }
  398.             }
  399.         }
  400.     }
  401.     return err;
  402. }
  403. //
  404. //since source is same as internal form, just execute it and store the result
  405. //
  406. pascal ComponentResult DoOSACompileExecute(GlobalsHandle globals, AEDesc  *sourceData,
  407.                                  OSAID  contextID, long  modeFlags,
  408.                                  OSAID *resultingScriptValueID)
  409. {
  410.     ComponentResult err;
  411.     AEDesc  resultDesc, anoDesc;
  412.  
  413.     err = AEDuplicateDesc(sourceData, &anoDesc);
  414.     if( err == noErr ){
  415.         anoDesc.descriptorType = MySignature;
  416.         err = ActualDoScript(globals, &anoDesc, &resultDesc);
  417.         if( err == noErr ) {  
  418.             err = FindSlotAndPutIt(globals, resultDesc,(long *) resultingScriptValueID); 
  419.         }
  420.         AEDisposeDesc(&anoDesc);
  421.     }
  422.     return err;
  423. }
  424.  
  425. //
  426. //since source is same as internal form, just execute it and return the result
  427. //
  428. pascal ComponentResult DoOSADoScript(GlobalsHandle globals, AEDesc  *sourceData, OSAID  contextID, 
  429.                                     DescType  desiredType, long  modeFlags, AEDesc *resultingText )
  430. {
  431.     ComponentResult   err;
  432.     AEDesc  resultDesc;
  433.  
  434.     (*sourceData).descriptorType = MySignature; 
  435.     NukeIt(resultingText);
  436.     err = ActualDoScript(globals, sourceData, &resultDesc);
  437.     if( err == noErr) { 
  438.         if( (desiredType == resultDesc.descriptorType) || (desiredType == typeWildCard) ){ 
  439.             err = AEDuplicateDesc( &resultDesc, resultingText); 
  440.         }
  441.         else {
  442.             if( desiredType == 'STXT') { 
  443.                 err = TextToStxt(resultDesc, resultingText);
  444.             }
  445.             else {
  446.                 err = AECoerceDesc(&resultDesc, desiredType, resultingText);
  447.                 AEDisposeDesc(&resultDesc);
  448.             }
  449.         }
  450.     }
  451.     return err;
  452. }
  453.  
  454. //
  455. //context is not used in this sample program 
  456. //
  457. pascal ComponentResult DoOSAMakeContext(GlobalsHandle globals, AEDesc  *contextName,
  458.                               OSAID parentContext, OSAID *resultingContextID )
  459. {
  460.     *resultingContextID = 0;
  461.     return noErr;
  462. }
  463.  
  464. //
  465. //return the name of the scripting component
  466. //
  467. pascal OSAError DoOSAScriptingComponentName(GlobalsHandle globals,
  468.                                          AEDesc *resultingScriptingComponentName)
  469. {
  470.     char  aStr[] = "SampleScript";
  471.  
  472.     return AECreateDesc(typeChar, &aStr[0], 12, resultingScriptingComponentName);
  473. }
  474.  
  475. //
  476. //execute the script and return a number or set the error result
  477. //
  478. ComponentResult ActualDoScript(GlobalsHandle globals, AEDesc *scriptData,
  479.                             AEDesc *result)
  480. {
  481.     
  482.     int num;
  483.     OSErr err;
  484.  
  485.     err = TryDoScript(globals, scriptData, &num);
  486.     if( err == noErr) { // THEN 
  487.         err = AECreateDesc(typeShortInteger, &num, sizeof(int), result);
  488.     }
  489.     return err;
  490. }
  491.  
  492. //try to compile the text and return the result 
  493. //we just try to translate one, two, three etc into a number in this simple example  
  494. //
  495. ComponentResult TryDoScript(GlobalsHandle globals, AEDesc *scriptData, int  *num)
  496. {
  497.     char aStr[256] ;
  498.     char  myDigits[10][20] = {"ONE","TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN" };
  499.     OSErr  err;
  500.     int i;
  501.     short myLong;
  502.     char    myComment[256] = "Cannot understand ";
  503.     StringPtr    thePtr;
  504.        
  505.     *num = 0;
  506.     if( (*scriptData).descriptorType == MySignature ) {
  507.         HLock((*scriptData).dataHandle);
  508.         myLong = GetHandleSize((*scriptData).dataHandle);    
  509.         BlockMove(*((*scriptData).dataHandle), &aStr[0],myLong);
  510.         aStr[myLong] = '\0';
  511.         HUnlock((*scriptData).dataHandle);
  512.   
  513.         for(i=0; i < 10; i++){  
  514.             if(myStrcmp(aStr, myDigits[i])){
  515.                 *num = i + 1;
  516.                 break;
  517.             }
  518.         }
  519.         ClearErrorDesc(globals);
  520.         if( *num == 0){
  521.             if(myStrcat(myComment, aStr) == noErr){
  522.                 err = errOSAScriptError;
  523.                 HLock((Handle)globals);
  524.                 (*globals)->errorNumber = err;
  525.                 PtrToXHand( &myComment[0], ((*globals)->errorDesc).dataHandle, myStrlen( myComment)  );
  526.                 HUnlock((Handle)globals);
  527.             }
  528.         }
  529.         else {
  530.             err = noErr;
  531.         }
  532.     }
  533.     else{
  534.         err = errOSABadStorageType;
  535.     }
  536.     return err;
  537. }
  538.  
  539.  
  540. typedef struct  
  541. {
  542.     int scrpNStyles;
  543.     ScrpSTElement  scrpStyle;
  544. }myStyleRec ; 
  545.  
  546.  
  547. //
  548. //convert TEXT to styled text
  549. //
  550. OSErr TextToStxt(AEDesc textDesc, AEDesc *result)
  551. {
  552.     OSErr err;
  553.     AERecord theRec;
  554.     myStyleRec myStyle;
  555.  
  556.     (*result).dataHandle = nil;
  557.     myStyle.scrpNStyles = 1;
  558.     myStyle.scrpStyle.scrpStartChar = 0;
  559.     myStyle.scrpStyle.scrpHeight = 16;
  560.     myStyle.scrpStyle.scrpAscent = 12;
  561.     myStyle.scrpStyle.scrpFont = 1;
  562.     myStyle.scrpStyle.scrpFace = bold; 
  563.     myStyle.scrpStyle.scrpSize = 12;
  564.     myStyle.scrpStyle.scrpColor.red = 0;
  565.     myStyle.scrpStyle.scrpColor.green = 0;
  566.     myStyle.scrpStyle.scrpColor.blue = 0;
  567.  
  568.     err = AECreateList(nil, 0, true, &theRec);
  569.     if( err == noErr){  
  570.         err = AEPutKeyPtr(&theRec, 'ksty', 'styl', &myStyle, sizeof(myStyle));
  571.         if( err == noErr) { 
  572.             err = AEPutKeyDesc(&theRec, 'ktxt', &textDesc);
  573.         }
  574.         if( err == noErr){ 
  575.             err = AECoerceDesc(&theRec, 'STXT', result); 
  576.         }
  577.         AEDisposeDesc(&theRec);
  578.     }
  579.     return err;
  580. }
  581.  
  582. //
  583. //clean up the error message
  584. //
  585. void ClearErrorDesc(GlobalsHandle globals)
  586. {
  587.     HLock((Handle)globals);
  588.     (*globals)->errorNumber = noErr;
  589.     SetHandleSize(((*globals)->errorDesc).dataHandle, 0);
  590.     HUnlock((Handle)globals);
  591. }
  592.  
  593. //
  594. //added this since the documentation says its required 
  595. //returning noErr
  596. pascal ComponentResult DoOSASetScriptInfo(GlobalsHandle globals, OSAID scriptID,
  597.                               OSType selector, long value)
  598. {
  599.     ComponentResult myResult = noErr;
  600.  
  601.     if( selector == kOSAScriptIsModified ){
  602.         myResult = noErr;
  603.     }
  604.     return myResult;
  605.  
  606. }
  607.  
  608. //
  609. //added this since the documentation says its required 
  610. //
  611. pascal ComponentResult DoOSAGetScriptInfo(GlobalsHandle globals,  OSAID scriptID,
  612.                               OSType selector, long * value)
  613. {
  614.     ComponentResult myResult = noErr;
  615.  
  616.     switch ( selector ) {
  617.             
  618.         case kOSAScriptIsModified: 
  619.             *value = 1;
  620.             break;
  621.                 
  622.         case kOSAScriptIsTypeCompiledScript:
  623.             *value = 1;
  624.             break; 
  625.                
  626.         case kOSAScriptIsTypeScriptValue:
  627.             *value = 1;
  628.             break; 
  629.                 
  630.         case kOSAScriptIsTypeScriptContext:
  631.             *value = 1;
  632.             break; 
  633.                 
  634.         case kOSAScriptBestType:
  635.             *value = (long) typeChar;
  636.             break; 
  637.                                 
  638.         case kOSACanGetSource:
  639.             *value = 1;
  640.             break;     
  641.                 
  642.         default :
  643.             myResult = paramErr;
  644.     }
  645.     return myResult;       
  646. }
  647.  
  648. //
  649. //if two strings are the same return 1 otherwise return 0
  650. //make them case independent
  651. //
  652. int myStrcmp( char * firstString, char * secString)
  653. {
  654.     int     i=0;
  655.     short    myShort, aShort;
  656.     
  657.     
  658.     aShort = (short) ('a' - 'A' );
  659.     while( firstString[i] != '\0' ){
  660.         myShort = (short) ( firstString[i] - secString[i] );
  661.         if( ( (myShort % aShort) == 0  )&&(secString[i] != '\0')){
  662.             i++;
  663.         }
  664.         else{
  665.             return 0;
  666.         }
  667.     }
  668.     
  669.     if(secString[i] != '\0')
  670.         return 0;
  671.     else
  672.         return 1;        
  673. }
  674.  
  675. //
  676. //concatenate two strings the second to the first
  677. //
  678. OSErr myStrcat( char * firstString, char * secString)
  679. {
  680.     int i = 0;
  681.     int j = 0;
  682.     OSErr    myErr;
  683.     
  684.     while( (firstString[i] != '\0') && i < 100){
  685.         i++;
  686.     }
  687.     if( i == 100){
  688.         myErr = 1; //some error
  689.         return myErr;
  690.     }
  691.     while( (secString[j] != '\0') && j < 100){
  692.         firstString[i+j] = secString[j];
  693.         j++;
  694.     }
  695.     if( j == 100){
  696.         myErr = 1; //some error
  697.         return myErr;
  698.     }
  699.     firstString[i+j] = '\0';
  700.     return noErr;
  701. }
  702.  
  703. //
  704. // get the string length
  705. //
  706. int myStrlen( char * theString)
  707. {
  708.     int i=0;
  709.     
  710.     while( (theString[i] != '\0') && (i< 200) ){
  711.         i++;
  712.     }
  713.     return i+1;
  714. }
  715.